e.Toscana 
Compliance Request for Comments: 65 
Del: 11/10/2007 
Categoria: Applicativa
Destinatari: Regione Toscana, Amministrazioni locali 


ARPA (Autenticazione Ruoli Profili Applicazioni) 


Indice 
------
1. Contesto di riferimento	
2. Obiettivi	
3. Analisi 
4. Prodotti attesi
5. Bibliografia


1. Contesto di riferimento
==========================

Il progetto ARPA (Autenticazione Ruoli Profili Applicazioni) si colloca nel 
quadro delle attivit volte alla realizzazione di Infrastrutture per 
l'autenticazione e l'accesso ai servizi ed alle informazioni finalizzate alla 
diffusione di sistemi sicuri di riconoscimento telematico (certificati 
digitali) e alla creazione di modalit attraverso le quali a chi accede in 
rete sia possibile associare, nel rispetto della legge sulla privacy, i diritti 
di accesso e visibilit di classi di informazioni e servizi.

Il progetto prevede la realizzazione di uninfrastruttura di Autenticazione ed 
Accesso Sicuro ai servizi di Regione Toscana, ottenuta dallintegrazione della 
piattaforma di Access Management con i servizi offerti dal framework SRTY e 
dalla piattaforma di Cooperazione Applicativa di Regione Toscana (CART).

L'infrastruttura di Autenticazione ed Accesso Sicuro  realizzata utilizzando 
le funzionalit di Autenticazione, Autorizzazione ed Accesso di Sun Java System 
Access Manager insieme alle funzionalit di Aggregazione e Profilazione basata 
su ruoli definiti da un sistema Role manager integrato con Sun Portal ed SRTY. 

Il risultato  la costruzione di un Portale per l'accesso sicuro alle risorse 
applicative di Regione Toscana che consente di centralizzare l'accesso degli 
utenti, rafforzandolo di strumenti di autenticazione sicuri quali le smart card, 
offrendo all'utente un desktop personalizzato sulla base del proprio ruolo. 

L'interazione tra il portale (PORTAL) ed il modulo di gestione dei ruoli  (ROLE 
MANAGER) consente di  disaccoppiare il controllo accessi basato sui ruoli dalla 
gestione delle banche dati utilizzate per la validazione dei ruoli stessi.

Elemento chiave dell'infrastruttura ARPA  la capacit di interoperare con 
altre amministrazioni secondo il modello di identit federata, basato cio su 
un rapporto di fiducia legato all'identit dell'utente. Va interpretata, in 
questo senso la capacit del portale di accogliere soggetti gi autenticati 
presso altre Amministrazioni offrendo comunque loro servizi basati sulla 
profilazione per ruolo. La stessa capacit di operare secondo scenari di identit 
federata, viene offerta agli utenti profilati sul portale di accesso sicuro che 
vogliano accedere ai servizi offerti da altre Amministrazioni a fronte 
dell'autenticazione effettuata sul portale. 

L'utilizzo di standard aperti, la possibilit di utilizzare i servizi della 
piattaforma di autenticazione ed autorizzazione sia attraverso il portale che 
richiamandoli direttamente dalle applicazioni consentono a Regione Toscana di far 
evolvere le proprie applicazioni utilizzando l'infrastruttura di autenticazione 
ed autorizzazione del portale.


2. Obiettivi
============ 

Gli obiettivi della piattaforma sono:
 centralizzare l'accesso degli utenti (meccanismi di Single Sign On - SSO);
 raggiungere e fruire, da internet, di applicazioni web non raggiungibili in 
  assenza del sistema ARPA (applicazioni relegate alla intranet aziendale);
 favorire e diffondere lutilizzo di  strumenti di autenticazione sicuri 
  quali ad esempio le smart card e CNS;
 offrire all'utente un desktop personalizzato sulla base del proprio ruolo; 
 disaccoppiare il controllo accessi  basato sui ruoli dalla gestione delle banche 
  dati utilizzate per la validazione dei ruoli stessi;
 interoperare con altre amministrazioni secondo il modello di identit federata, 
  basato cio su un rapporto di fiducia legato all'identit dell'utente.



3. Analisi 
==========

3.1 Individuazione dei moduli applicativi e relativi ruoli nella cooperazione
------------------------------------------------------------------------------

L'architettura  composta da quattro aree funzionali principali, corrispondenti 
ai seguenti sottosistemi:

ROLE MANAGER	
Descrizione:
Verifica che gli utenti abbiano diritto ai ruoli che dichiarano di possedere, 
interrogando, attraverso una serie di Adapter, le diverse fonti dati. 
Consente di gestire ruoli, criteri, risorse e lassociazione tra essi.
Interazione con CART:	
Pubblica sul CART gli eventi collegati alle operazioni dinserimento, modifica e 
cancellazione di ruoli, risorse, attributi e criteri.

PORTAL	
Descrizione:
Si occupa dell'autenticazione degli utenti e del controllo degli accessi alle risorse 
disponibili attraverso il portale. E' responsabile della costruzione del desktop per 
l'utente autenticato e profilato all'interno del portale.
Interazione con CART:
Legge dal CART gli eventi pubblicati dal ROLE MANAGER. Reagisce agli eventi pubblicati, 
collegati alle operazioni dinserimento, modifica e cancellazione di ruoli, risorse, 
attributi e criteri, modificando dinamicamente la struttura dei ruoli di portale  e le 
policy daccesso alle risorse cos come descritto nel paragrafo dedicato alla definizione 
dei requisiti.
Interazione con ROLE MANAGER:
Contatta il blocco ROLE MANAGER mediante chiamate a servizi da questo esposti 
(Web Services) per la validazione delle associazioni ruolo/utente e il recupero dei valori 
degli attributi associati al ruolo in questione.
Interazione con GENERIC:
Scambia informazioni con le applicazioni appartenenti al blocco GENERIC per offrire, 
in vari modi, lintegrazione di queste nel portale fino a garantire raggiungibilit dei 
servizi, fruibilit e  Single Sign-On (SSO). Per ogni applicazione integrata nel portale, 
la raggiungibilit del sevizio viene offerta mediante unazione di reverse proxy offerta 
dal blocco PORTAL. Per la fruibilit del servizio e il Single Sign-On le modalit di azione 
possono essere diverse a seconda dellapplicazione da integrare: potrebbero essere previsto 
linvio di informazioni su HTTP Header, linterazione con meccanismi di Form Authentication 
piuttosto che Basic o Digest o altro meccanismo custom, luso di AM SDK o AM Policy Agent 
ed altro ancora.
Interazione con SRTY:
Mediante un meccanismo di reverse proxy offre la raggiungibilit, dallesterno, del servizio 
pubblicato su SRTY. Inoltre, centralizza lautenticazione e lautorizzazione daccesso ai 
servizi offerti.

GENERIC
Descrizione:
Rappresentano le applicazioni preesistenti o di futuro sviluppo che possono essere integrate 
e rese fruibili attraverso il PORTAL. Tali applicazioni, non sviluppate mediante il framework 
SRTY, sono associate ai vari ruoli tramite linterfaccia damministrazione del ROLE MANAGER.
Interazione con PORTAL:
Alcune applicazioni appartenenti al blocco GENERIC potrebbero avere la necessit di comunicare 
direttamente con il PORTAL; ad esempio applicazioni che fanno uso di AM SDK o AM Policy Agent. 

SRTY
Descrizione:
SRTY  il framework di sviluppo della applicazioni profilate ad accesso sicuro di Regione 
Toscana. Nell'ambito del framework SRTY possiamo identificare con SRTY Applications, gli 
applicativi installati nell'ambiente SRTY e con SRTY Core l'ambiente nel quale vengono 
installate le applicazione che utilizzano questo framework. Le SRTY Applications si interfacciano 
con il PORTAL per il reperimento delle credenziali dellutente e vengono associate ai vari ruoli 
tramite linterfaccia di amministrazione del ROLE MANAGER.
Interazione con PORTAL:
Poich il PORTAL offre i meccanismi di autenticazione e autorizzazione per SRTY, tale blocco 
logico ha la necessit di comunicare con il PORTAL. La comunicazione avviene su HTTP/s mediante 
luso del framework AM SDK. LAM SDK  usato dalle singole applicazioni del blocco SRTY per 
recuperare alcune informazioni relative allutente e dallAM Policy Agent per recuperare, 
interpretare ed applicare le politiche di autorizzazione.
Interazione con CART:
SRTY legge dal CART gli eventi pubblicati dal ROLE MANAGER reagendo agli eventi collegati 
allinserimento, modifica e cancellazione di un ruolo, come riportato nel paragrafo dedicato 
alla specifica dei requisiti.


3.2 Schema XML dei messaggi di cooperazione
-------------------------------------------

Lo schema XML  il seguente (CartNotifyBody.xsd) :

<?xml version="1.0" encoding="UTF-8"?>
<!-- edited with XMLSpy v2007 (http://www.altova.com) by vin (vin) -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">
	<xs:element name="ARPA_ROLE_EVENT" type="ARPA_ROLE_EVENTType">
		<xs:annotation>
			<xs:documentation>Messaggio CART di variazione su Ruolo</xs:documentation>
		</xs:annotation>
	</xs:element>
	<xs:complexType name="ARPA_ROLE_EVENTType">
		<xs:sequence>
			<xs:element name="ROLE" type="ROLEType"/>
		</xs:sequence>
		<xs:attribute name="ID" type="xs:long" use="required">
			<xs:annotation>
				<xs:documentation>Identificativo progressivo di evento su ruolo</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="NAME" use="required">
			<xs:annotation>
				<xs:documentation>Nome evento occorso</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:restriction base="xs:string">
					<xs:enumeration value="insert">
						<xs:annotation>
							<xs:documentation>Inserimento di un nuovo ruolo</xs:documentation>
						</xs:annotation>
					</xs:enumeration>
					<xs:enumeration value="update">
						<xs:annotation>
							<xs:documentation>Aggiornamento del ruolo</xs:documentation>
						</xs:annotation>
					</xs:enumeration>
					<xs:enumeration value="delete">
						<xs:annotation>
							<xs:documentation>Rimozione del ruolo</xs:documentation>
						</xs:annotation>
					</xs:enumeration>
				</xs:restriction>
			</xs:simpleType>
		</xs:attribute>
		<xs:attribute name="ROLEID" type="xs:long" use="required">
			<xs:annotation>
				<xs:documentation>Identificativo univoco del ruolo a cui si riferisce l'evento</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="ONLY_RESOURCE_MODIFIED" type="xs:boolean" use="optional"/>
	</xs:complexType>
	<xs:complexType name="ROLEType">
		<xs:sequence minOccurs="0">
			<xs:element name="ATTRIBUTES" type="ATTRIBUTESType" minOccurs="0"/>
			<xs:element name="RESOURCES" type="RESOURCESType" minOccurs="0"/>
		</xs:sequence>
		<xs:attribute name="ROLENAME" type="xs:string" use="required">
			<xs:annotation>
				<xs:documentation>Nome corrente del ruolo</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="PARENTID" type="xs:long" use="optional">
			<xs:annotation>
				<xs:documentation>ID del padre in caso di ruolo non Root</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="ADMIN_LEVEL" type="xs:int" use="optional">
			<xs:annotation>
				<xs:documentation>Livello privilegi di amministrazione del Ruolo</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:complexType>
	<xs:complexType name="ATTRIBUTESType">
		<xs:sequence maxOccurs="unbounded">
			<xs:element name="ATTRIBUTE" type="ATTRIBUTEType"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="RESOURCESType">
		<xs:sequence maxOccurs="unbounded">
			<xs:element name="RESOURCE" type="RESOURCEType"/>
		</xs:sequence>
	</xs:complexType>
	<xs:complexType name="ATTRIBUTEType">
		<xs:attribute name="NAME" type="xs:string" use="required"/>
		<xs:attribute name="DESCRIPTION" type="xs:string" use="optional"/>
	</xs:complexType>
	<xs:complexType name="RESOURCEType">
		<xs:sequence minOccurs="0" maxOccurs="unbounded">
			<xs:element name="URL_MAPPING" type="URL_MAPPINGType"/>
		</xs:sequence>
		<xs:attribute name="NAME" type="xs:string" use="required"/>
		<xs:attribute name="DESCRIPTION" type="xs:string" use="optional"/>
		<xs:attribute name="URL" type="xs:string" use="required"/>
		<xs:attribute name="ACCESS_LEVEL" type="xs:long" use="optional"/>
	</xs:complexType>
	<xs:complexType name="URL_MAPPINGType">
		<xs:attribute name="VALUE" type="xs:string" use="required"/>
		<xs:attribute name="DESCRIPTION" type="xs:string" use="optional"/>
	</xs:complexType>
</xs:schema>



4. Prodotti attesi
==================

4.1 Componenti applicative e relative interazioni
--------------------------------------------------

Di seguito viene riportata una vista logica della comunicazione prevista 
tramite CART tra ROLE MANAGER, PORTAL ed SRTY.

Dal punto di vista logico esiste sia un proxy pubblicatore sia un proxy 
sottoscrittore: in realt  possibile anche realizzare un solo modulo che, 
opportunamente configurato, funziona nelle due modalit.
 
+--------------------+    +-----------------+       +-----------------+ 
|                    |    |                 |       |                 |
| ROLE MANAGER (SIL) |    |   SRTY (SIL)    |       |   PORTAL (SIL)  |
|                    |    |                 |       |                 |
|  RoleSync Server   |    | RoleSync Client |<--+-->| RoleSync Client | 
|                    |    |                 |   |   |                 |
+--------------------+    +-----------------+   |   +-----------------+ 
  |                                             |
  |                                             |      
  |    +---------------------------------------------------------------+
  |    |                                        |                      | 
  |    |    +--------------+                    |  +----------------+  |
  |    |    |              |                    |  |                |  |
  |    |    |    (NAL)     |                    +--|     (NAL)      |  |
  |    |    |              |     +-----------+     |                |  |
  |    |    |    Proxy     |     |           |     |     Proxy      |  |
  +----|--->| Pubblicatore |---->|   CRIC    |---->| Sottoscrittore |  |
       |    |              |     |           |     |                |  |
       |    +--------------+     +-----------+     +----------------+  |
       |                                                               |
       | CART                                                          |
       |                                                               | 
       +---------------------------------------------------------------+

        Figura 1 - Interazione dei sottosistemi ARPA tramite CART

I vari sottosistemi vengono riconsiderati come parti di uninfrastruttura di 
Cooperazione Applicativa: in particolare ROLE MANAGER, SRTY e PORTAL sono SIL 
al cui interno vengono definite le componenti che si interfacciano con il CART.

In maggior dettaglio:

- Proxy pubblicatore: invocato da un solo SIL (ROLE MANAGER); i messaggi inviati 
dal SIL non contengono allegati; il proxy effettua la validazione XML del messaggio 
inviato dal SIL e la trasmette al CRIC attraverso la SoleFacade.

- Proxy sottoscrittore: serve pi SIL (SRTY e PORTAL attualmente, ma se ne possono 
prevedere altri in futuro); i messaggi ricevuti dal CRIC non contengono allegati; 
il proxy preleva dal CRIC, attraverso la SoleFacade, i messaggi provenienti dal 
proxy pubblicatore: tali messaggi vengono inviati ai SIL e, una volta consegnati, 
consumati; la consumazione dei messaggi  indipendente per ogni SIL.

- RoleSyncServer: invoca il proxy pubblicatore inviando un messaggio senza allegati; 
ogni messaggio sar dotato di un identificativo univoco progressivo che consentir 
ai RoleSyncClient  di ricostruire il flusso corretto ed ordinato dei messaggi.

- RoleSyncClient: lavora in modalit PUSH, ossia viene contattato dal CRIC alla 
consegna dei messaggi; poich linfrastruttura non garantisce che lordine di consegna 
sia lo stesso dellinvio n che i messaggi vengano consegnati una ed una sola volta, 
tali controlli verranno implementati dai RoleSyncClient utilizzando un identificativo 
univoco progressivo di messaggio apposto dal RoleSyncServer.

Maggior dettagli sui tali moduli vengono illustrati nel documento [8].


4.2 WSDL per l'implementazione dei servizi richiesti
----------------------------------------------------

Per realizzare l'applicazione server (RoleSyncServer pubblicazione dei ruoli) viene fornito 
il seguente WSDL (scaricabile anche da http://carttestnal.rete.toscana.it/arpaproxy/pubblica)
 
<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:tns="jada/arpaproxy" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" name="arpaproxy" targetNamespace="jada/arpaproxy">
  <types/>
  <message name="ArpaProxyIF_pubblica">
    <part name="String_1" type="xsd:string"/>
  </message>
  <message name="ArpaProxyIF_pubblicaResponse">
    <part name="result" type="xsd:string"/>
  </message>
  <portType name="ArpaProxyIF">
    <operation name="pubblica" parameterOrder="String_1">
      <input message="tns:ArpaProxyIF_pubblica"/>
      <output message="tns:ArpaProxyIF_pubblicaResponse"/></operation>
  </portType>
  <binding name="ArpaProxyIFBinding" type="tns:ArpaProxyIF">
    <operation name="pubblica">
      <input>
        <soap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" use="encoded" namespace="jada/arpaproxy"/>
      </input>
      <output>
        <soap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" use="encoded" namespace="jada/arpaproxy"/>
      </output>
      <soap:operation soapAction=""/>
    </operation>
    <soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="rpc"/>
    </binding>
  <service name="Arpaproxy">
    <port name="ArpaProxyIFPort" binding="tns:ArpaProxyIFBinding">
      <soap:address xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" location="http://carttestnal.rete.toscana.it:80/arpaproxy/pubblica"/> 
    </port>
  </service>
</definitions>

Per realizzare l'applicazione client (RoleSyncClient ricezione notifiche sui ruoli) viene fornito 
il seguente WSDL:
 
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions targetNamespace="http://portal.cart.tix.it:80/axis/services/RoleSyncClientEventReceiver" xmlns:apachesoap="http://xml.apache.org/xml-soap" xmlns:impl="http://portal.cart.tix.it:80/axis/services/RoleSyncClientEventReceiver" xmlns:intf="http://portal.cart.tix.it:80/axis/services/RoleSyncClientEventReceiver" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<!--WSDL created by Apache Axis version: 1.4
Built on Apr 22, 2006 (06:55:48 PDT)-->
   <wsdl:message name="receiveEventsRequest">
      <wsdl:part name="xmlEvents" type="xsd:string"/>
   </wsdl:message>
   <wsdl:message name="receiveEventsResponse">
      <wsdl:part name="receiveEventsReturn" type="xsd:string"/>
   </wsdl:message>
   <wsdl:portType name="EventReceiver">
      <wsdl:operation name="receiveEvents" parameterOrder="xmlEvents">
         <wsdl:input message="impl:receiveEventsRequest" name="receiveEventsRequest"/>
         <wsdl:output message="impl:receiveEventsResponse" name="receiveEventsResponse"/>
      </wsdl:operation>
   </wsdl:portType>
   <wsdl:binding name="RoleSyncClientEventReceiverSoapBinding" type="impl:EventReceiver">
      <wsdlsoap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/>
      <wsdl:operation name="receiveEvents">
         <wsdlsoap:operation soapAction=""/>
         <wsdl:input name="receiveEventsRequest">
            <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" namespace="http://rolesyncclient.portal.arpa.regione.toscana.it" use="encoded"/>
         </wsdl:input>
         <wsdl:output name="receiveEventsResponse">
            <wsdlsoap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" namespace="http://portal.cart.tix.it:80/axis/services/RoleSyncClientEventReceiver" use="encoded"/>
         </wsdl:output>
      </wsdl:operation>
   </wsdl:binding>
   <wsdl:service name="EventReceiverService">
      <wsdl:port binding="impl:RoleSyncClientEventReceiverSoapBinding" name="RoleSyncClientEventReceiver">
         <wsdlsoap:address location="http://portal.cart.tix.it:80/axis/services/RoleSyncClientEventReceiver"/>
      </wsdl:port>
   </wsdl:service>
</wsdl:definitions>



4.3 Proxy Applicativo ARPA, configurazioni ed utilizzo
------------------------------------------------------

Il proxy ARPA espone un servizio, pubblica, che accetta come unico parametro il body 
in XML di un evento di tipo ARPA_ROLE_EVENT.
Tramite l'invocazione del servizio, ARPA_RoleManager pubblica nel CART gli eventi relativi 
alla gestione dei ruoli, risorse e attributi. Eventi che vengono raccolti da ARPA_SRTY ed 
ARPA_Portal per l'allineamento delle proprie basi informative. 
La configurazione del CART relativamente all'evento ARPA_ROLE_EVENT e' la seguente :

	<EVENT name="ARPA_ROLE_EVENT">
		<NAL name="carttestnal">
			<APPLICATION name="arpaproxy">
				<SIL name="SIL_ARPA_RoleManager"
					type="pub"
					StartDate="30112006"
					EndDate="31122016"
					Sync="false"
					url="">
				</SIL>
				<SIL name="SIL_ARPA_SRTY"
					type="sub"
					StartDate="30112006"
					EndDate="31122016"
					Sync="false"
					url="">
				</SIL>
				<SIL name="SIL_ARPA_Portal"
					type="sub"
					StartDate="30112006"
					EndDate="31122016"
					Sync="false"
					url="">
				</SIL>
			</APPLICATION>
		</NAL>
	</EVENT>

Il proxy viene configurato per servire piu' SIL sottoscrittori tramite l'uso di una 
lista di liste in forma di stringa di caratteri. In essa gli attributi di ogni SIL, 
separati da spazio, sono separati da quelli del SIL successivo dal carattere #.
Naturalmente, in caso di introduzione di nuovi SIL sottoscrittori, la configurazione 
dell'evento nel CART deve essere concordemente allineata.


5. Bibliografia
===============

[1]	Regione Toscana, Infrastruttura per la Cooperazione Applicativa   C.A.R.T.
        Il Modello e l'Architettura, 02 Dicembre 2003
[2]	Regione Toscana, Infrastruttura per la Cooperazione Applicativa   C.A.R.T.
        Linee guida per lo sviluppo dei proxy applicativi, 02 Dicembre 2003
[3]	Regione Toscana, Proxy Developer Kit Ver. 1.5, 
        Infrastruttura per la Cooperazione Applicativa, 20 settembre 2004
[4]	Regione Toscana, Deployment di un'applicazione in ambiente NAL Ver. 1.8,
        ottobre 2004
[5]	Regione Toscana, Progetto A3 CART, Infrastruttura di servizi per la
        Cooperazione Applicativa, Giugno 2003
[6]	Regione Toscana, PETRA NAL - Kit per gli sviluppatori,
        Guida all'installazione Ver. 3.1.1,  Luglio 2004
[7]	RRTI Telecom-Sun-Siemens, ARPA - SPECIFICHE FUNZIONALI. 
	ver. 0.16a, luglio 2006
[8]	RTI Telecom-Sun-Siemens, ARPA - PROGETTAZIONE DELLE COMPONENTI SOFTWARE, 
	ver 0.5  dicembre 2006
[9]	RTI Telecom-Sun-Siemens, PROXY APPLICATIVO ARPAPROXY, v0.4, 10 ottobre 2007
